Data joining/displaying method

ABSTRACT

A plurality of table-formatted data can be joined at a high speed without requiring use of a large capacity of memory. Each table-formatted data is divided into one or more information blocks consisting of a value list containing item values in the order of item value numbers corresponding to the item values belonging to a particular item and a pointer array containing pointer values specifying the item value numbers in the order of uniquely-defined record number. When joining a plurality of table formats, equivalent items between the table-formatted data are found and the value lists contained in the information block concerning the equivalent items are compared and the two value lists are made equivalent. After this, data of one of the table formats is sorted according to a key item and by using the array obtained in this process, calculation is performed to obtain addresses indicating storage positions of record numbers of the table-formatted data and the other table-formatted data. By using the calculated addresses, joined table-formatted data is displayed.

TECHNICAL FIELD

The present invention relates to a data processing method and a dataprocessing apparatus for processing a large amount of data by using aninformation processing apparatus such as a computer, and moreparticularly to a method and an apparatus for concatenating pluraltable-format data in a relational database and for retrieving,tabulating and sorting item values of desired records or the like.

BACKGROUND OF THE INVENTION

Although databases are used for various uses, the use of a relationaldatabase (RDB) which can eliminate a logical contradiction has becomethe mainstream in a medium-scale to large-scale system. For example, theRDB is used in a system of an airline seat reservation or the like. Inthis case, by specifying a key item, it is possible to quickly retrievetargets (one target in many cases), or to confirm, cancel or changereservations. Besides, since the number of seats on each flight isseveral hundred at most, it is also possible to obtain the number ofempty seats on a specific airline flight.

However, it is known that when an attempt is made to use this RDB toperform a specific operation (for example, calculation of the loadfactor) for each fiscal year, each day of the week, each month, eachroute, each time zone or each type of airplane, it takes a very longtime. That is, while the RDB is superior in realizing a processingwithout contradictions, it has poor performance in searching, tabulatingor sorting a considerable number of records.

Thus, in recent years, for the purpose of searching and tabulating, ithas become general to construct a database called a data warehouse (DWH)in a system in addition to the RDB. That is, an extremely large-scaledatabase having specific data formats and data item names to match thespecific purpose of the end user is constructed, and the end user canuse this to perform specific searches and tabulation.

However, to provide the DWH in addition to the RDB, that is, to provideplural databases deviates from the original form that the database,especially the RDB, was contrived for the purpose of enabling thecentral control of data, and this causes various problems as describedbelow.

(1) Since the DWH is static, it is difficult to perform searching andtabulation of items other than those previously provided in the DWH.

(2) Since the static DWH is provided in addition to the RDB, the datacapacity becomes extremely large, and it cannot deal with the update ofthe RDB and the like.

In view of the above problems, the present inventor invented a method ofrealizing a high speed join and filed this (PCT/WO00/73939). Also inthis method, it is desirable that a data area necessary at an operationcan be further reduced. Also in the above method of the join, there is aproblem that a relatively large memory space is required since an arrayis created which becomes a product set of part of table-format data tobe joined.

The present invention has an object to provide a structure oftable-format data in which plural table-format data can be joined atdesired high speeds and its data capacity is small, a concatenatingmethod thereof, and a method of presenting the concatenated table-formatdata at extremely high speeds.

Besides, the invention has an object to provide a method in which at thetime of a join processing, a large amount of data areas are not requiredfor that.

DISCLOSURE OF THE INVENTION

The object of the invention is achieved by a concatenating/presentingmethod of concatenated table-format data, in which plural table-formatdata each expressed as an array of records containing an item and itemvalues contained therein are concatenated and the concatenatedtable-format data is presented, the method characterized by comprising

a step of constructing each of the table-format data to divide it intoone or more information blocks each including a value list in which inorder of item value numbers corresponding to item values belonging to aspecific item, the item values are stored, and a pointer array in whichpointer values for indicating the item value numbers are stored in orderof unique record numbers,

a step of finding an item to be made common to the plural table-formatdata,

a step of specifying information blocks relating to the item to be madecommon,

a step of comparing value lists contained in the specified informationblocks in the plural table-format data to make both the value listsequivalent to each other,

a step of, when the value lists are made equivalent, converting apointer array in accordance with addition of an item value in theinformation block in which the item value is added and creating a newpointer array,

a step of, with respect to the plural table-format data and among theinformation blocks relating to the specific item, deciding ontable-format data in which default sort order is reflected atpresentation to be master table format data, and deciding ontable-format data other than that to be slave table-format data,

a step of, in the information block which constitutes the slavetable-format data and in which the item value becomes equivalent,creating a slave side existence number array for storing an existencenumber indicating the number of records relating to the slavetable-format data correspondingly to the item value,

a step of referring to the existence number in the slave side existencenumber array and creating a slave side accumulation number array storingan accumulation number of the existence numbers corresponding to theitem value,

a step of, in the information block which constitutes the mastertable-format data and in which the item value becomes equivalent,extracting a pointer value in the pointer array indicated by a masterside record number,

a step of specifying an element in the slave side existence number arrayindicated by the pointer value, making it correspond to a master siderecord number, and placing it in a record number indication arrayindicating the number of records of the slave table-format datacorresponding to each record of the master table-format data,

a step of referring to the number of records in the record numberindication array and creating a master side accumulation number arrayfor storing an accumulation number of the number of recordscorresponding to the master side record number,

a step of obtaining a total sum of the accumulation number of the numberof records with respect to the master side accumulation number array andcreating a new record number array capable of containing the total sumnumber of elements and for specifying a new record relating to theconcatenated table-format data,

a step of obtaining a first resultant array containing a record numberin the master table-format data in view of duplication by comparing anew record number in the new record number array with an element in themaster side accumulation number array,

a step of specifying an element in the pointer array relating to theslave table-format data indicated by the record number in the mastertable-format data as an element in the first resultant array,

a step of specifying an element in the slave side accumulation numberarray indicated by the element in the pointer -array relating to theslave table-format data and temporarily holding it as a slave side startaddress, and

a step of obtaining a second resultant array containing a record numberin the slave table-format data in view of duplication from a recordnumber in the record number array, an element in the master accumulationnumber array specified by the record number, and the slave side startaddress,

wherein an item value in the value list relating to the master sideinformation block is extracted on the basis of the record numbercontained in the first resultant array, and an item value in the valuelist of the slave side information block is extracted on the basis ofthe record number contained in the second resultant array.

The principle of the invention will be described below. In the casewhere the table-format data are concatenated, in both the master sideand the slave side, what is expressed on one row before concatenationappears on one or plural rows. Accordingly, a method of mapping the oneoriginal row to the plural rows must be found. For example, a mostprimitive method of realizing this is to copy the record the pluralnumber of times. For example, when an array of a record number isoriginally (0, 1, 2), and when each record is copied twice, (0, 0, 1, 1,2, 2) is obtained. However, it takes an extremely long time to copy therecord.

Then, it is conceivable to use an array (repeat number array) containingthe number of times that each record should be copied, that is, shouldbe repeated. In the above example, the repeat number array becomes (2,2, 2). In order to decide a row of the concatenated view (table) byusing this repeat number array, for example, calculation as describedbelow becomes necessary.

For example, when it is desired to know a third row of the concatenatedtable, on the basis that the first element =2 of the repeat number arraydoes not reach “3”, and the first element+second element of the repeatnumber array =4 reaches “3”, it is understood that the record at themaster side second row corresponds to the third row in the concatenatedtable.

In the invention, an accumulation number array is previously obtained,so that the above calculation can be omitted. That is, the repeat numbercan be calculated very easily from the accumulation number array. Moreparticularly, the new record number in the new record number array andthe element in the master side accumulation number array are comparedwith each other, so that the first resultant array containing the recordnumber in the master table-format data in view of duplication can beobtained. The second resultant array containing the record number in theslave table-format data in view of duplication can also be obtained fromthe value in the first resultant array, the value in the master sideaccumulation number array and the like.

Besides, the object of the invention is achieved by aconcatenating/presenting method of concatenated table-format data, inwhich plural table-format data each expressed as an array of recordscontaining an item and item values contained therein are concatenatedand the concatenated table-format data is presented, the methodcharacterized by comprising:

a step of constructing each of the table-format data to divide it intoone or more information blocks each including a value list in which inorder of item value numbers corresponding to item values belonging to aspecific item, the item values are stored, and a pointer array in whichpointer values for indicating the item value numbers are stored in orderof unique record numbers,

a step of finding an item to be made common to the plural table-formatdata,

a step of specifying information blocks relating to the item to be madecommon,

a step of comparing value lists contained in the specified informationblocks in the plural table-format data to make both the value listsequivalent to each other,

a step of, when the value lists are made equivalent, converting apointer array in accordance with addition of an item value in theinformation block in which the item value is added and creating a newpointer array,

a step of, with respect to the plural table-format data and among theinformation blocks relating to the specific item, deciding ontable-format data in which default sort order is reflected atpresentation to be master table format data, and deciding ontable-format data other than that to be slave table-format data,

a step of, in the information block which constitutes the slavetable-format data and in which the item value becomes equivalent,creating a slave side existence number array for storing an existencenumber indicating the number of records relating to the slavetable-format data correspondingly to the item value,

a step of referring to the existence number in the slave side existencenumber array and creating a slave side accumulation number array storingan accumulation number of the existence numbers corresponding to theitem value,

a step of, in the information block which constitutes the mastertable-format data and in which the item value becomes equivalent,extracting a pointer value in the pointer array indicated by a masterside record number,

a step of specifying an element in the slave side accumulation numberarray on the basis of the pointer value, making it correspond to themaster side record number, and placing it in a record number indicationarray indicating the number of records of the slave table-format datacorresponding to respective records of the master table-format data, thenumber of records being for an item value which is not larger than theitem value in the value list indicated by the pointer value or less thanthe item value in sort order of the master side value list,

a step of referring to the number of records in the record numberindication array and creating a master side accumulation number arrayfor storing an accumulation number of the numbers of recordscorresponding to the master side record number,

a step of obtaining a total sum of the accumulation number of the numberof records with respect to the master side accumulation number array andcreating a new record number array capable of containing the total sumnumber of elements and for specifying a new record relating to theconcatenated table-format data,

a step of obtaining a first resultant array containing record numbers inthe master table-format data in view of duplication by comparing a newrecord number in the new record number array with an element in themaster side accumulation number array,

a step of specifying an element in the pointer array relating to theslave table-format data and indicated by the record number in the mastertable-format data as the element in the first resultant array,

a step of specifying an element in the slave side accumulation numberarray indicated by the element in the pointer array relating to theslave table-format data and temporarily holding it as a slave side startaddress, and

a step of obtaining a second resultant array containing record numbersin the slave table-format data in view of duplication from the recordnumber in the record number array, the element in the masteraccumulation number array specified by the record number, and the slaveside start address,

wherein the item value in the value list relating to the master sideinformation block is extracted on the basis of the record numbercontained in the first resultant array, and the item value in the valuelist of the slave side information block is extracted on the basis ofthe record number contained in the second resultant array.

By this, it becomes possible to create the table (view) containing theslave side item values which become the master side item value or lessin the sort order of the concatenated items, or the slave side itemvalues which becomes less than the master side item value.

For example, in order to acquire those not larger than the master sideitem value, there is provided a step of specifying an element in theslave side accumulation number array corresponding to a value larger byone than a value indicated by the pointer value, and placing, by this,it in a record number indication array indicating the number of recordsof the item value which is not larger than the item value in the valuelist indicated by the pointer value in sort order of the master sidevalue list.

In a preferred embodiment, the step of creating the first resultantarray includes a step of specifying a position where an element in themaster accumulation number array, whose value is not larger than the newrecord number and is maximum, is stored, and a step of specifying anelement in the new record number array indicated at the position andarranging it to a corresponding position in the first resultant array.

Besides, in a more preferable embodiment, the step of creating thesecond resultant array includes a step of calculating a differencebetween the record number in the record number array and the element inthe master accumulation number array which is not larger than the newrecord number and is maximum, a step of adding the element temporarilyheld as the start address and the calculated difference, and a step ofarranging a value obtained by the addition to a corresponding positionin the second resultant array.

Besides, the object of the invention is achieved by a program forcausing a computer to execute the above steps.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 is a block diagram showing a hardware configuration of a computersystem which can realize a retrieving, tabulating and searching methodaccording to an embodiment of the invention.

FIG. 2 is a view showing an information block used in the embodiment.

FIG. 3A is a view showing an example of table-format data, and

FIGS. 3B to 3D are views respectively showing examples of informationblocks based on the table-format data.

FIG. 4A is a view showing another example of table-format data, and

FIGS. 4B and 4C are views respectively showing other examples ofinformation blocks based on the table-format data.

FIG. 5 is a flowchart showing a retrieving method relating to a singleitem.

FIGS. 6A and 6B are views showing a relation between a record number andan item value with respect to a certain item, and a completedinformation block of the embodiment.

FIG. 7 is a flowchart showing the outline of a compile processing of theembodiment.

FIGS. 8A and 8B are views for explaining original data of table-formatdata and data extracted from this, respectively.

FIG. 9 is a view showing a joined table (view) based on the table-formatdata shown in FIGS. 8A and 8B.

FIG. 10 is a flowchart showing the outline of a concatenating processingof table-format data according to the embodiment and a presentingprocessing.

FIG. 11A is a view showing a structure of an information block oftable-format data according to the embodiment, and

FIG. 11B is a view showing extracted table-format data.

FIG. 12A is a view showing a structure of an information block of othertable-format data according to the embodiment, and

FIG. 12B is a view showing extracted table-format data.

FIG. 13 is a flowchart showing a sharing processing according to theembodiment in more detail.

FIGS. 14A and 14B are views for explaining information blocks at thesharing processing according to the embodiment.

FIG. 15 is a view for explaining an information block at the sharingprocessing according to the embodiment.

FIG. 16 is a view for explaining the sorting of slave side table-formatdata in the embodiment.

FIG. 17A is a view for explaining the sorting of slave side table-formatdata in the embodiment, and

FIG. 17B is a view showing the sorted slave side table-format data.

FIG. 18 is a view for explaining an array of master side table-formatdata necessary for creation of a table (view) in the embodiment.

FIG. 19 is a flowchart showing a processing of specifying a master siderecord number and a slave side record number on the basis of a recordnumber of a join table in order to obtain a view in the embodiment.

FIG. 20 is a view showing a state in which a master side and a slaveside record numbers are specified in the embodiment.

FIG. 21 is a view showing a state in which a master side and a slaveside record numbers are specified in the embodiment.

FIG. 22 a view showing a state in which a master side and a slave siderecord numbers are specified in the embodiment.

FIG. 23 a view showing a state in which a master side and a slave siderecord numbers are specified in the embodiment.

FIG. 24 a view showing a state in which a master side and a slave siderecord numbers are specified in the embodiment.

FIG. 25 is a view for explaining the acquisition of a view joined on thebasis of the obtained record numbers in the embodiment.

FIG. 26 is a view showing an example of a view presented in aninequality join according to another embodiment.

FIG. 27 is a view for explaining the creation of a record number listand the like in an inequality join according to another embodiment.

PREFERRED MODE FOR CARRYING OUT THE INVENTION

Hereinafter, an embodiment of the present invention will be describedwith reference to the accompanying drawings. FIG. 1 is a block diagramshowing a hardware configuration of a computer system which can realizethe joining of table-format data according to the embodiment of theinvention, and the retrieving, tabulating and sorting of the joineddata. As shown in FIG. 1, this computer system 10 has a similarconfiguration to a normal one, and includes a CPU 12 for controlling thewhole system and respective components by executing a program, a RAM(Random Access Memory) 14 for storing work data and the like, a ROM(Read Only Memory) 16 for storing the program and the like, a fixedstorage medium 18 such as a hard disk, a CD-ROM driver 20 for accessinga CD-ROM 19, an interface (I/F) 22 provided between the CD-ROM driver 20and an external terminal connected to an external network (not shown),an input device 24 including a keyboard and a mouse, and a CRT displaydevice 26. The CPU 12, the RAM 14, the ROM 16, the external storagemedium 18, the I/F 22, the input device 24 and the display device 26 aremutually connected through a bus 28.

A program for concatenating (joining) table-format data according tothis embodiment, a program for creating a table (view) of specifieditems from the concatenated table-format data, a searching program, atabulating program and a sorting program are contained in the CD-ROM 19,and may be read by the CD-ROM driver 20, or may be previously stored inthe ROM 16. Besides, what is once read out of the CD-ROM 19 may bestored in a specified area of the external storage medium 18.Alternatively, the program may be supplied from the outside through thenetwork (not shown), the external terminal and the I/F 22.

Besides, in this embodiment, in order to realize searching, tabulatingand sorting at high speed, as described later, it is necessary to createan information block of a specified data format. This information blockcreation program may also be stored in-the CD-ROM 19, stored in the ROM16, or stored in the external storage medium 18. Alternatively, theseprograms may be naturally supplied from the outside through the network(not shown). Besides, in this embodiment, the data (information block)created by the information block creation program is stored in the RAM14 or stored in a specified area of the external storage medium 18.

Next, a description will be given to a data format as the premise of theinvention, and the principle of searching, tabulating and sorting. Thepresent inventor contrived the construction of table-format data havinga specific data format, and a searching, tabulating and sorting methodlast year, in order to realize a super high speed processing (seePCT/WO00/10103). Also in the present invention, the table-format data isbasically constructed as an aggregate of specified information blocksbased on this application, and the searching, tabulating and sorting arerealized by using this. First, a brief description will be given to thestructure of the information block and the searching using this.

FIG. 2 is a view showing the information block used in this embodiment.As shown in FIG. 2, an information block 100 includes a value list 110,and a pointer array 120 to the value list. The value list 110 is a tablein which with respect to each item of table-format data, item valuesbelonging to the item are stored in the order of ordered (integer) itemvalue numbers and the item values 111 corresponding to the item valuenumbers are stored. The pointer array 120 to the value list is an arrayin which the item value numbers of a certain column (that is, an item)of the table-format data, that is, pointers to the value list 110 arestored in the order of record numbers of the table-format data.

By combining the pointer array 120 to the value list and the value list110, when a certain record number is given, an item value number storedcorrespondingly to the record number is extracted from the pointer array120 to the value list relating to the specified item, and next, the itemvalue stored correspondingly to the item value number in the value list110 is extracted, so that the item value can be obtained from the recordnumber. Accordingly, similarly to a conventional data table, all data(item values) can be referred to by using a coordinate of the recordnumber (row) and the item (column).

For example, table-format data shown in FIG. 3A will be considered. Inthis example, various item values are given to items of a customer ID, acustomer name, and a telephone number. In this embodiment, thetable-format data as stated above is held as information blocks offormats shown in FIGS. 3B to 3D. For example, in FIG. 3B, a pointerarray 120-1 is associated with a value list 110-1 storing item valuesindicating customer IDs. That is, a pointer value of the pointer arrayat a leading record (record number “0”) is 0, and an item value “1”indicating the customer ID is obtained correspondingly to this. In FIG.3C, a pointer array 120-2 is associated with a value list 110-2 storingitem values indicating the customer names. For example, a pointer valueof the pointer array at a leading record (record number “0”) is “5”, andan item value “King” indicating the customer name is obtainedcorrespondingly to this. Also in FIG. 3D, it is understood that apointer array 120-3 is similarly associated with a value list 110-3storing item values indicating the telephone numbers. Besides, it isunderstood that in each of the value lists, the item values are ordered(in this example, ascending order).

Further, in this embodiment, a value management table of the informationblock 100 includes, in addition to the value list 110, a class numberflag array used for searching and tabulation, a start position arrayindicating a start address of a memory space in which pointerscorresponding to item values are to be stored, and an existence numberarray. The respective flags of the class number flag array, and therespective existence numbers of the existence number array are made tocorrespond to the respective item values. A flag value of the classnumber flag is normally “0”, and is set to “1” correspondingly to anitem value to be found at the searching or tabulation. Besides, theexistence number corresponds to the number of records having the itemvalue. Incidentally, since the start position corresponds to what isobtained by adding the existence numbers corresponding to pointer valuessmaller than the corresponding pointer value, it is not always necessaryto provide the start position.

FIG. 4A is a view showing another example of table-format data, andFIGS. 4B and 4C are views showing information blocks respectivelyrelating to “gender” and “age”. As shown in FIG. 4B, in a valuemanagement table 210-1 of an information block 200-1 relating to thegender, there are shown item values (“male” and “female”) correspondingto respective pointer values of a pointer array 220-1, and classnumbers, start positions and existence numbers corresponding to therespective item values. For example, the number of records in which thepointer value is “0” (that is, the item value of the value list is“male”) is 632564, while the number of records in which the pointervalue is “1” (that is, the item value of the value list is “female”) is367436. Besides, the start positions corresponding to the respectiveitem values indicate start addresses of a pointer array 230-1 torecords. It is understood that the same applies to FIG. 4C.

An example of searches using the information block having the datastructure as stated above will be described below. FIG. 5 is a flowchartshowing a searching method relating to a single item. The CPU 12 (seeFIG. 1) executes a specified searching program so that this processingis realized. In this example, records in which the item value of “age”is the age of sixteen or the age of nineteen are searched. First, amonginformation blocks relating to the table-format data, an informationblock 200-2 shown in FIG. 4C and relating to “age” is specified (step501).

Next, in a value list 210-2 of the specified information block(hereinafter referred to as “specified information block”), a classnumber of a row corresponding to an item value which meets the searchcondition (the age of sixteen or the age of nineteen) is set to “1”(step 502). In the case of this example, the class numbers of rowscorresponding to the item value number “0” and the item value number “3”are set to 1. Next, the start position and the existence numbercorresponding to the row in which the class number is set to “1” areacquired (step 503). The information is referred to as pointerextraction information. In the pointer array to records, a record numberindicating a pointer to a record meeting the search condition isextracted on the basis of the pointer extraction information acquired atthe step 503 (step 504). In this example, it is understood that pointersof records corresponding to the item value number “0” are stored in anarea from the start position “0” of the pointer array to records, thatis, the head to a 45898th position, while pointers of recordscorresponding to the item value number “3” are stored in an area for189653 pointers from a 2383137th position of the pointer array torecords. Finally, in order that they can be used in a later processing,an array of the extracted record numbers is created as a resultant set,and this is held (step 505).

Besides, tabulating and sorting can also be realized by using the classnumber, the start position and the existence number.

Next, a description will be given to a compile processing for creatingthe information block. In this compile processing, a value list iscreated in which data arranged at random concerning a certain item aresorted without duplication and in specified order (for example, in theorder of the Japanese syllabary or in the order of alphabet). FIG. 6A isa view showing records and item values of a certain item (family name)in table-format data. In the compile processing of this embodiment, withrespect to the item in which the item values are arranged at random asshown in FIG. 6A, an information block with a format as shown in FIG. 6Bis created.

In FIG. 6B, an information block 600 includes a pointer array 601(hereinafter referred to as “PV”) to a value list, and a value list 602.Immediately after the compile processing, the value list 602 isconstituted by an array (original item value array) 603 containingoriginal item values and an array 604 (hereinafter referred to as “VLP”)indicating storage position numbers of the original item value array603. The pointer array (PV) can be said a position specifying array in asense that it specifies item values in the value list. Besides, the VLPcan be said an order specifying array in a sense that it indicates theorder of item values. Although the information block immediately afterthe compile processing is slightly different from the information blockshown in FIG. 3B in the format, it can be made to have an equivalentformat by an after-mentioned processing.

FIG. 7 is a flowchart showing the outline of the compile processing ofthis embodiment. As shown in FIG. 7, in the compile processing, thecomputer system 10 reads out the table-format data stored in the fixedstorage medium 18 or the like (step 701), and specifies an item in whichit is necessary to create an information block (step 702). For example,the information blocks may be created for all items, and only theinformation block relating to a specified arbitrary item may be created.Besides, it is desired that the read table-format data is temporarilystored in the RAM 14 in view of the processing time.

Next, the computer system 10 selects the specified item from thetable-format data, and the data (item value) relating to the item ismade to correspond to the record number and is cut (step 703). By this,for example, data of a format shown in FIG. 6A can be extracted. Next,the information block relating to the item is created (step 704). Thisprocessing will be described later in detail. The processing of thesteps 703 and 704 is carried out with respect to all the specified items(see steps 705 and 706). By this, the information blocks relating to thespecified items are completed.

In this way, it becomes possible to create the information blocksrelating to the specified items. The creation of the information blocksis previously performed, and the processing of searching, tabulating andsorting is carried out by using the created information blocks.

Now, a description will be given below to a processing of combining twotable-format data (execution of JOIN processing) and creating one table(view). Incidentally, in the present specification, in the informationblock, an array (item value array) in which item values concerning acertain item are arranged is referred to as a “value list”. Besides,values contained in various arrays are referred to as “elements”according to circumstance.

For example, as shown in FIG. 8A, attention is paid to a certain item(here, “area”) and a table 801 is created in which only members having acertain item value are extracted from a table (member table of abaseball fan club) 800. On the other hand, as shown in FIG. 8B,attention is paid to a certain item (here, “baseball field”) and a table811 is created in which only baseball fields having a specified itemvalue are extracted from another table (for example, a baseball gameschedule table) 810.

As shown in FIG. 8A, the member table 800 (called “member originaltable” since a set of records is extracted and the member table 801 isformed from this) has record numbers as member IDs and has items of“member name”, “area”, “baseball team name (fan) which a member likes”,and values are given to the respective items in each record. On theother hand, as shown in FIG. 8B, the game schedule table 810 (similarlyto the above, this is called “game schedule original table”) has recordnumbers as baseball team IDs, and has items of “baseball team name”,“game day”, “baseball field name”, and values are given to therespective items in each record.

In this embodiment, the item of the fan in the member table and the itemof the baseball team in the game schedule table are used as keys tocarry out the join processing, and finally, as shown in FIG. 9, a tableshowing games of the baseball team which the member likes and which areopened in the area of the member can be presented as a view (see numeral900).

Incidentally, although the member table 801 and the game schedule table811 are basically equal to each other, the table in which the defaultsort order of the output table (view) is reflected is referred to as“master table”, and the other table is referred to as “slave table”. Theexample of FIGS. 8A and 8B and FIG. 9 indicates a state in which thenumbers (member IDs) given to the members are sorted, and the membertable 801 becomes the master table, and on the other hand, the gameschedule table 811 becomes the slave table. Besides, in the presentspecification, according to circumstances, the master table is referredto as master table-format data, and the slave data is referred to asslave table-format data.

FIG. 10 is a flowchart showing the outline of a join processing. First,records having a specified item value, for example, “Tokyo” in a certainitem, for example, “area” are searched from the master table (step1001), and then, similarly, records having a specified item value in acertain item are searched from the slave table (step 1002). In thissearch, the processing shown in FIG. 5 is performed. By the processingof the step 1001 and the step 1002, on the basis of the baseball fanclub original table 800, the baseball fan club member table 801 can beformed (see FIG. 8A), and besides, the game schedule table 811 can becreated from the game schedule original table 810 (see FIG. 8B).

For example, the baseball fan club original table is as shown in FIG.11A. Here, there are initially information blocks 1101, 1102, and 1103for the respective items of “member name”, “area” and “fan”. In theinformation block, there are provided a value list (for example, seereference numeral 1111) storing item values in the specified order (inthe order of the Japanese syllabary or in the order of alphabet) and apointer array (for example, see reference numeral 1112) storing pointervalues corresponding to the respective record numbers and for specifyingitem value numbers in the item value table.

Besides, by the search processing, as shown in FIG. 11B, an ordered setarray 1121 is created in which extracted record numbers are stored.Pointer values in the pointer array of each of the information blocks,and item values indicated by the pointer values can be specified byusing the record numbers in the ordered set array. By this, a viewincluding item values of the respective items, which are made tocorrespond to the extracted records, can be formed (see referencenumeral 1122). Incidentally, in the processing of the join, it is notnecessary to create the view 1122 and to present it to the user.

The game schedule original table is as shown in FIG. 12A. Here, thereare initially information blocks 1201, 1202 and 1203 for the respectiveitems of “baseball team”, “game day” and “baseball field”. In each ofthe information blocks, similarly to the baseball fan club memberoriginal table, a pointer array (for example, see reference numeral1212) and a value list (for example, see reference numeral 1211) areprovided. Besides, by the search processing, as shown in FIG. 12B, anordered set array 1221 is formed in which extracted record numbers arestored.

Next, an item as a key is made common (step 1003). FIG. 13 is aflowchart showing a sharing processing shown at the step 1003. As shownin FIG. 13, first, with respect to the item as the key, the value listat the master table side and the value list at the slave side arecompared with each other (step 1301).

In the example shown in FIGS. 8A, 8B to FIGS. 11A, 11B, the item “fan”at the master table side and the item “baseball team” at the slave tableside are made common. As shown in FIG. 14A, item values contained in avalue list 1401 of an information block 1103 relating to the item “fan”at the master table side are compared with item values contained in thevalue list 1211 of the information block 1201 relating to the item“baseball team” at the slave table side (see an arrow 1410 in FIG. 14A).

A shared value list is created (step 1302, an arrow 1411 of FIG. 14A).The shared value list (see reference numeral 1402) has a form of logicalproduct (AND) of the item values in the value list at the master tableside and the item values in the value list at the slave table side.

Thereafter, a conversion array (see reference numeral 1403) between thevalue list at the master table side and the shared value list is created(step 1303). The conversion array 1403 at the master table side storesvalues indicating item values in the shared value list corresponding tothe respective item values of the original value list. Similarly, aconversion array (see reference numeral 1404) between the value list atthe slave table side and the shared value list is also created (step1304).

When the conversion array is created, pointer values in the pointerarray at the master table side and pointer values in the pointer arrayat the slave table side are rewritten through the conversion arrays(steps 1305 and 1306). For example, as shown in FIG. 14B, at the mastertable side, reference is made to a pointer value of a certain storageposition number, and reference is made to a value in the conversionarray 1403 arranged at a position indicated by the pointer value. Thereference value becomes a new pointer value of the storage positionnumber in the pointer array. Similarly, also at the slave table side,reference is made to a pointer value of a certain storage positionnumber in the pointer array 1421 and a value in the conversion array1404 arranged at a position indicated by the pointer value is specified,and the value becomes a new pointer value of a storage position number.

In this way, as shown in FIG. 15, there are obtained an informationblock (see reference numeral 1501) at the master table side, whichincludes the pointer array whose pointer values are renewed and theshared value list, and an information block (see reference numeral 1502)at the slave table side, which includes the pointer array whose pointvalues are renewed and the shared value list. Incidentally, in the stateof FIG. 15, with respect to the item as the key, the value list iscommon. Accordingly, it is not necessary to keep two value lists, andboth the information blocks may use the single value list.

When sharing of the value list is ended, at the slave table side,sorting is carried out according to the item as the key, and anexistence number array is created which indicates the number of recordshaving each item value in the value list with respect to the item as thekey (step 1004 in FIG. 10). This sort processing will be described inbrief. As shown in FIGS. 4B and 4C, the information block of thisembodiment includes plural arrays each having the same element number asthe number of item values in the value list. An explanation will be madeagain. A numerical value in the start position array indicates the startaddress of the pointer array to records, and a numerical value in theexistence number array indicates the number of records indicating theitem value.

FIG. 16 is a view for explaining a processing at the time when the slaveside game schedule table is sorted while a baseball team name is used asa key. As shown in FIG. 16, in the information block relating to thebaseball team name, there are a shared value list 1601, and a pointerarray 1602 after conversion. In the game schedule table, only elementsindicated by record numbers contained in an ordered set have only to besorted.

Then, by reference to the pointer value in the pointer array indicatedby the element in the ordered set, the element in an existence numberarray and at a position indicated by the pointer value is incremented,so that an examination is made on what number of times the value list isindicated. By this, it becomes possible to obtain an existence numberarray 1603.

Elements in an accumulation number array (this is the same as “startposition array”) 1604 can be decided from elements in the existencenumber array. This is obtained in such a manner that an accumulationnumber of elements in the existence number array is made an element at astorage position lower by one (that is, a storage position number islarger by one) in the start position array. For example, in theaccumulation number array, an element at the third storage positionnumber becomes a total sum of elements up to the second storage positionnumber in the existence number array, that is, “1”. Similarly, forexample, an element at the fourth storage position number in theaccumulation number array becomes a total sum of elements up to thethird storage position number in the existence number array, that is,“1+2=3”. Besides, an end position array 1605 indicates anafter-mentioned pointer array 1606 to records. The respective elementsare initially the same as those of the accumulation number array.

When the start position array and the existence number array are createdin this way, the respective elements (record numbers) in the ordered setare extracted in the order of the storage position number. An item valuein the value list 1601 is specified from the element in the pointerarray indicated by the record number. When the item value in the valuelist is specified, an element in the end position array and at thestorage position number where the item value is arranged is specified.The element becomes a value in the pointer array to records. Besides,the relevant element in the end position array is incremented.

For example, in the ordered array, since the record number at the 0thstorage position number is “0”, the storage position number “0” isspecified in the pointer array 1602 (see an arrow 1610). The pointervalue corresponding to the storage position number is “5”, and the fifthelement “3” in the end position array becomes the element at the 0thstorage position number (see reference numerals 1611 and 1612). Besides,the fifth element in the end position array is incremented and becomes“4” (see an arrow 1613). By repeating the processing as stated above,the pointer array to the records is formed.

When the pointer array to the records is used, as shown in FIG. 17A, theordered set in which the record numbers are arranged can be converted.In this way, the ordered set after conversion is used, and in the orderof the storage position numbers, the pointer array to the value list inthe information block and elements in the value list are specified onthe basis of the record numbers stored in the ordered set afterconversion, so that a view shown in FIG. 17B and sorted by the baseballteam name can be obtained.

In this way, after the creation (step 1004 of FIG. 10) of the existencenumber array and the like are ended, an accumulation number arrayrelating to the master side is created (step 1005). Here, there arecreated a record number list indicating the number of slave side recordscorrespondingly to an after-mentioned master side record number, and amaster side accumulation number array in which record numbers areaccumulated.

More particularly, by reference to a pointer value in a pointer array(see reference numeral 1802) indicated by a record number arranged in anordered set (see reference numeral 1801 of FIG. 18) at the master side,a value at a storage position number indicated by the pointer value isspecified in an existence number array (see reference numeral 1810) atthe slave side. Next, an element (existence number) in the specifiedexistence number array is arranged at a position relating to a storageposition number where the initial record number is arranged in a recordnumber list (see reference numeral 1803).

For example, in an example of FIG. 18, since the 0th element (recordnumber) of the ordered set 1801 is “0”, in the pointer array 1802, thepointer value “3” corresponding to “0” of the storage position number isextracted (see an arrow 1811). Next, in the existence number array 1810,the element “2” contained correspondingly to the storage position number“3” is extracted (see an arrow 1812), and this is stored as the “0”thelement of the record number list 1803 (see an arrow 1813). By repeatingthe processing as stated above, the number of records at the slave sidecorresponding to the record number can be known for each record numberin the ordered set 1811 at the master side.

When the existence number array is created, the accumulation numberarray at the master side on the basis of this is created. Moreparticularly, the accumulation number of the element in the recordnumber list has only to be made the element at the storage positionlower by one (that is, the storage position number is larger by one) inthe accumulation number array. For example, in the accumulation numberarray, “2” as the element at the 0th storage position number of therecord number list is contained at the first position. “2+1=3” as theaccumulation number up to the first storage position number of therecord number list is contained at the second position. In this way, anaccumulation number array 1804 at the master side can be obtained.Incidentally, a total sum of the numbers of records in the record numberlist 1803 is added in the accumulation number array 1804 at the masterside (see reference numeral 1805). The total sum of the numbers ofrecords becomes the total sum of the records of the view after the join.A record number after the join is called “a record number of a jointable”.

A processing to obtain a joined view is carried out by using the arraycreated in this way. FIG. 19 is a flowchart showing a processing ofspecifying a master side record number and a slave side record number onthe basis of the record number of the join table in order to obtain theview. Incidentally, in the processing shown in FIG. 19, among thevarious arrays formed at the step 1004 and the step 1005 of FIG. 10, theaccumulation number array at the master side and the ordered setcontaining the record numbers at the master side are referred to as afirst projection array and a second projection array, respectively.Besides, the accumulation number array at the slave side and the orderedset containing the record numbers at the slave side are referred to as athird projection array and a fourth projection array, respectively.

After storage position numbers for specifying the array containingrecord numbers of the join table are initialized (step 1901), the recordnumber indicated by the storage position number is extracted (step1902), and in the first projection array, a maximum position where itselement is not larger than the extracted record number is specified(step 1903).

For example, as shown in FIG. 20, a 0th record number “0” is initiallyextracted from an array 2001 containing record numbers of the jointable. In a first projection array 2002, since an element having arecord number “0” or less is “0”, the maximum position becomes the 0thposition where “0” is contained (see an arrow 2011). Besides, as shownin FIG. 21, a first record number “1” is extracted from an array 2101containing record numbers of the join table. In a first projection array2102, since an element whose record number is “1” or less is “0”, amaximum position becomes a 0th position where “0” is contained (see anarrow 2111).

On the other hand, in FIG. 22, in the case where a second record number“2” is extracted from an array 2201 containing record numbers of thejoin table, in a first projection array 2202, an element having a recordnumber “2” or less is “2. Accordingly, a maximum position becomes thefirst position where “2” is contained in the first projection array (seean arrow 2211).

Next, a value in a second projection array corresponding to the positionacquired at the step 1903 is acquired (step 1904). The value in thesecond projection array becomes a record number at the master side. Whenthe record number at the master side is obtained, in the pointer arrayat the slave side, the pointer value at a position indicated by therecord number is extracted by using the record number (step 1906). Next,in a third projection array, a value at a position indicated by thepointer value is acquired (step 1907).

For example, in FIG. 20, the value “0” in the second projection arraycorresponding to the position (0th) acquired at the step 1903 becomesthe record number at the master side (see an arrow 2012). Besides, thepointer value “3” in the pointer array arranged at the positionindicated by the record number “0” at the master side is extracted (seean arrow 2013).

In the third projection array, the value arranged at the positionindicated by the pointer value acquired at the step 1907 is acquired(step 1908). In the example of FIG. 20, the value “1” in the thirdprojection array at the position corresponding to the pointer value “3”is acquired (see an arrow 2014). In this way, by using various acquiredvalues, the record numbers at the slave side are calculated.

More particularly, there are used the record number (first value) of thejoin table acquired at the step 1902, the value (second value) in thefirst projection array corresponding to the position specified at thestep 1903, and the value (third value) in the third projection arrayacquired at the step 1907. Here, (first value−second value)+third valueis calculated, so that the storage position number of the ordered set atthe slave side is obtained (step 1908). The value obtained here is madethe storage position number and the position of the ordered set isspecified, so that it becomes possible to acquire the record number atthe slave side (step 1909). In the example shown in FIG. 20, since “0”(see an arrow 2020) as the first value, “0” (see an arrow 2021) as thesecond value, and “1” (see an arrow 2022) as the third value areobtained, the storage position number for specifying the ordered set atthe slave side becomes “(0−0)+1=1” (see an arrow 2023). By this, arecord number “4” corresponding to the storage position number can beacquired (see an arrow 2024).

The storage position number of the ordered set at the slave side becomesthe (first value−second value)+third value for following reasons. Theset at the slave side is sorted by the key item (in the example,“baseball team”) of the join. Accordingly, the third value expresses thestart address of the key item of the specified join in the set at theslave side. On the other hand, with respect to the key item of the join,plural elements (that is, records) at the slave side can exist. The(first value−second value) indicates the placing of the element in theplural elements. That is, from the third value+(first value−secondvalue), it is possible to know the placing of the element from startaddress+start address.

FIGS. 20 to 24 are views for explaining acquisition of record numbers atthe master side and the slave side at each of the storage positionnumbers of “0” to “4” in the arrays storing record numbers of the joinedtable. As shown in FIGS. 20 to 24, it is understood that on the basis ofthe record number of the join table, the record number at the masterside and the record number at the slave side are acquired.

The processing of the step 1902 to the step 1909 of FIG. 19 is carriedout with respect to all storage position numbers of arrays containingthe record numbers of the join table, and by this, as shown in FIG. 25,there are obtained an array (master side record number array: seereference numeral 2501) corresponding to an array 2500 containing recordnumbers of the join table and containing record numbers at the masterside and an array (slave side record-number array: see reference numeral2502) containing record numbers at the slave side.

Record numbers are sequentially extracted from the array 2500, andrecord numbers in the master side record number array are specified, sothat the joined master side table 2610 made of item values of the itemsof “member name”, “area” and “fan” can be acquired. On the other hand,the record numbers in the slave side record number array are specified,so that the joined slave side table 2511 made of item values of items of“team”, “game day” and “baseball field” can be acquired.

As stated above, in this embodiment, after the value list relating tothe item as the key is made common, the slave side is sorted by the keyitem, and the array obtained in the process is used, so that thenumerical values (addresses) indicating the storage positions of therecord numbers at the master side and the slave side are calculated.Accordingly, by the extremely high speed processing, it becomes possibleto join two table-format data and to obtain the view using the joinedtable-format data.

The invention is not limited to the above embodiment, and it is needlessto say that various modifications can be made within the scope of theinvention recited in the claims, and those are contained in the scope ofthe invention.

For example, in the above embodiment, although the view is created inwhich the joined item values at the master side and the slave sidebecome the same, the invention is not limited to this, and it is alsopossible to create a view containing such slave side item values thatthe item values at the slave side are not larger than the item values atthe master side in the order of sorting, or less than the item values.Hereinafter, the former is referred to as “equality join”, and thelatter is referred to as “inequality join”.

FIG. 26 is a view showing an example of a view presented in theinequality join. In the example of FIG. 26, between the baseball team(fan) which the member at the master side likes and the baseball team atthe slave side, a relation of master side item value a slave side itemvalue is established. Here, the sign of inequality means that in theorder of sorting (in the example, in the order of alphabet), an itemvalue equal to an item value at the master side or smaller than the itemvalue, that is, the item value positioned in front appears at the slaveside. For example, with respect to the member who has “G-team” as theitem “fan” at the master side, records at the slave having the samevalue as that, or records having “D-team” of the item value smaller thanthat are enumerated.

A processing for realizing the join as stated above will be describedbelow in brief. Here, except for a part, the same processing as theprocessing shown in FIG. 10 is carried out. Although the steps 1001 to1004 of FIG. 10 are also carried out for the inequality join, thecreation of the record number list at the step 1005 and the creation ofthe master side accumulation number array based on this are differentfrom the processing relating to the equality join.

FIG. 27 is a view for explaining the creation of a record number listand the like in the inequality join. This corresponds to FIG. 18 in theequality join. In the inequality join, an element in an accumulationnumber array 2710 indicated by a value obtained by adding “1” to apointer value in a pointer array is specified. Incidentally, in theinequality join, a value indicating a final accumulation number is addedto the end in the accumulation number array 2710 at the slave side, (seereference numeral 2711). The above specified element is stored at aspecified position of the record number list (see reference numeral2712). Next, on the basis of the record number list 2712, a master sideaccumulation number array 2713 is created. Besides, an element (seereference numeral 2714) at the end of the master side accumulationnumber array is a total sum of record numbers in the record number list2712. A processing of obtaining the joined view by using these is thesame as that shown in FIG. 19.

Besides, in the embodiment, a specified program is loaded into thegeneral computer system 10, and the program is executed out, so that thejoin of plural table-format data and processing relating to the joinedtable-format data are realized. However, the invention is not limited tothis, and it is needless to say that configuration may be made in, sucha manner that a board computer dedicated for database processing isconnected to a general computer system such as a personal computer, andthe board computer can perform the above processing. Accordingly, in thepresent specification, the unit does not necessarily mean a physicalunit, but includes a case where a function of each unit is realized bysoftware or hardware. Further, a function of one unit may be realized bytwo or more physical units, or functions of two or more units may berealized by one physical unit.

According to the present invention, it becomes possible to provide astructure of table-format data in which plural table-format data can bejoined at a desired high speed, and whose data capacity is small, aconcatenating method thereof, and a presentation method of presentingthe joined table-format data at an extremely high speed. Besides,according to the invention, it becomes possible to provide a methodwhich does not require a large amount of data areas at the processing ofthe join.

Industrial Applicability

The present invention can be used especially for a system for managing alarge amount of data, for example, a database or a data warehouse. Morespecifically, it is used for large-scale scientific and technicalcalculation, basic business management such as accepting order/placingorder management or stock exchange, or business management.

1. A concatenating/presenting method of concatenated table-format data,in which plural table-format data each expressed as an array of recordscontaining an item and item values contained therein are concatenatedand the concatenated table-format data is presented, the methodcharacterized by comprising: a step of constructing each of thetable-format data to divide it into one or more information blocks eachincluding a value list in which in order of item value numberscorresponding to item values belonging to a specific item, the itemvalues are stored, and a pointer array in which pointer values forindicating the item value numbers are stored in order of unique recordnumbers; a step of finding an item to be made common to the pluraltable-format data; a step of specifying information blocks relating tothe item to be made common; a step of comparing value lists contained inthe specified information blocks in the plural table-format data to makeboth the value lists equivalent to each other; a step of, when the valuelists are made equivalent, converting a pointer array in accordance withaddition of an item value in the information block in which the itemvalue is added and creating a new pointer array; a step of, with respectto the plural table-format data and among the information blocksrelating to the specific item, deciding on table-format data in whichdefault sort order is reflected at presentation to be master tableformat data, and deciding on table-format data other than that to beslave table-format data; a step of, in the information block whichconstitutes the slave table-format data and in which the item valuebecomes equivalent, creating a slave side existence number array forstoring an existence number indicating the number of records relating tothe slave table-format data correspondingly to the item value; a step ofreferring to the existence number in the slave side existence numberarray and creating a slave side accumulation number array storing anaccumulation number of the existence numbers corresponding to the itemvalues; a step of, in the information block which constitutes the mastertable-format data and in which the item value becomes equivalent,extracting a pointer value in the pointer array indicated by a masterside record number; a step of specifying an element in the slave sideexistence number array indicated by the pointer value, making itcorrespond to the master side record number, and placing it in a recordnumber indication array indicating the number of records of the slavetable-format data corresponding to respective records of the mastertable-format data; a step of referring to the number of records in therecord number indication array and creating a master side accumulationnumber array for storing an accumulation number of the numbers ofrecords corresponding to the master side record number; a step ofobtaining a total sum of the accumulation number of the numbers ofrecords with respect to the master side accumulation number array andcreating a new record number array capable of containing the total sumnumber of elements and for specifying new records relating to theconcatenated table-format data; a step of obtaining a first resultantarray containing a record number in the master table-format data in viewof duplication by comparing a new record number in the new record numberarray with an element in the master side accumulation number array; astep of specifying an element in the pointer array relating to the slavetable-format data and indicated by the record number in the mastertable-format data as the element in the first resultant array; a step ofspecifying an element in the slave side accumulation number arrayindicated by the element in the pointer array relating to the slavetable-format data and temporarily holding it as a slave side startaddress; and a step of obtaining a second resultant array containing arecord number in the slave table-format data in view of duplication froma record number in the record number array, an element in the masteraccumulation number array specified by the record number, and the slaveside start address, wherein the item value in the value list relating tothe master side information block is extracted on the basis of therecord number contained in the first resultant array, and the item valuein the value list of the slave side information block is extracted onthe basis of the record number contained in the second resultant array.2. A concatenating/presenting method of concatenated table-format data,in which plural table-format data each expressed as an array of recordscontaining an item and item values contained therein are concatenatedand the concatenated table-format data is presented, the methodcharacterized by comprising: a step of constructing each of thetable-format data to divide it into one or more information blocks eachincluding a value list in which in order of item value numberscorresponding to item values belonging to a specific item, the itemvalues are stored, and a pointer array in which pointer values forindicating the item value numbers are stored in order of unique recordnumbers; a step of finding an item to be made common to the pluraltable-format data; a step of specifying information blocks relating tothe item to be made common; a step of comparing value lists contained inthe specified information blocks in the plural table-format data to makeboth the value lists equivalent to each other; a step of, when the valuelists are made equivalent, converting a pointer array in accordance withaddition of an item value in the information block in which the itemvalue is added and creating a new pointer array; a step of, with respectto the plural table-format data and among the information blocksrelating to the specific item, deciding on table-format data in whichdefault sort order is reflected at presentation to be master tableformat data, and deciding on table-format data other than that to beslave table-format data; a step of, in the information block whichconstitutes the slave table-format data and in which the item valuebecomes equivalent, creating a slave side existence number array forstoring an existence number indicating the number of records relating tothe slave table-format data correspondingly to the item value; a step ofreferring to the existence number in the slave side existence numberarray and creating a slave side accumulation number array storing anaccumulation number of the existence numbers corresponding to the itemvalue; a step of, in the information block which constitutes the mastertable-format data and in which the item value becomes equivalent,extracting a pointer value in the pointer array indicated by a masterside record number; a step of specifying an element in the slave sideaccumulation number array on the basis of the pointer value, making itcorrespond to the master side record number, and placing it in a recordnumber indication array indicating the number of records of the slavetable-format data corresponding to respective records of the mastertable-format data, the number of records being for an item value whichis not larger than the item value in the value list indicated by thepointer value or less than the item value in sort order of the masterside value list; a step of referring to the number of records in therecord number indication array and creating a master side accumulationnumber array for storing an accumulation number of the numbers ofrecords corresponding to the master side record number; a step ofobtaining a total sum of the accumulation number of the number ofrecords with respect to the master side accumulation number array andcreating a new record number array capable of containing the total sumnumber of elements and for specifying a new record relating to theconcatenated table-format data; a step of obtaining a first resultantarray containing record numbers in the master table-format data in viewof duplication by comparing a new record number in the new record numberarray with an element in the master side accumulation number array; astep of specifying an element in the pointer array relating to the slavetable-format data and indicated by the record number in the mastertable-format data as the element in the first resultant array; a step ofspecifying an element in the slave side accumulation number arrayindicated by the element in the pointer array relating to the slavetable-format data and temporarily holding it as a slave side startaddress; and a step of obtaining a second resultant array containingrecord numbers in the slave table-format data in view of duplicationfrom the record number in the record number array, the element in themaster accumulation number array specified by the record number, and theslave side start address, wherein the item value in the value listrelating to the master side information block is extracted on the basisof the record number contained in the first resultant array, and theitem value in the value list of the slave side information block isextracted on the basis of the record number contained in the secondresultant array.
 3. The method according to claim 2, characterized bycomprising a step of specifying an element in the slave sideaccumulation number array corresponding to a value larger by one than avalue indicated by the pointer value, and placing, by this, it in arecord number indication array indicating the number of records of theitem value which is not larger than the item value in the value listindicated by the pointer value in sort order of the master side valuelist.
 4. The method according to claim 1, characterized in that the stepof creating the first resultant array includes a step of specifying aposition where an element in the master accumulation number array, whosevalue is not larger than the new record number and is maximum, isstored, and a step of specifying an element in the new record numberarray indicated at the position and arranging it to a correspondingposition in the first resultant array.
 5. The method according to claim1, characterized in that the step of creating the second resultant arrayincludes a step of calculating a difference between a record number inthe record number array and an element in the master accumulation numberarray, which is not larger than the new record number and is maximum, astep of adding the element temporarily held as the start address and thecalculated difference, and a step of arranging a value obtained by theaddition to a corresponding position in the second resultant array.
 6. Aconcatenating/presenting program of concatenated table-format data, inwhich plural table-format data each expressed as an array of recordscontaining an item and item values contained therein are concatenatedand the concatenated table-format data is presented, the programcharacterized by causing a computer to execute: a step of constructingeach of the table-format data to divide it into one or more informationblocks each including a value list in which in order of item valuenumbers corresponding to item values belonging to a specific item, theitem values are stored, and a pointer array in which pointer values forindicating the item value numbers are stored in order of unique recordnumbers; a step of finding an item to be made common to the pluraltable-format data; a step of specifying information blocks relating tothe item to be made common; a step of comparing value lists contained inthe specified information blocks in the plural table-format data to makeboth the value lists equivalent to each other; a step of, when the valuelists are made equivalent, converting a pointer array in accordance withaddition of an item value in the information block in which the itemvalue is added and creating a new pointer array; a step of, with respectto the plural table-format data and among the information blocksrelating to the specific item, deciding on table-format data in whichdefault sort order is reflected at presentation to be master tableformat data, and deciding on table-format data other than that to beslave table-format data; a step of, in the information block whichconstitutes the slave table-format data and in which the item valuebecomes equivalent, creating a slave side existence number array forstoring an existence number indicating the number of records relating tothe slave table-format data correspondingly to the item value; a step ofreferring to the existence number in the slave side existence numberarray and creating a slave side accumulation number array storing anaccumulation number of the existence numbers corresponding to the itemvalues; a step of, in the information block which constitutes the mastertable-format data and in which the item value becomes equivalent,extracting a pointer value in the pointer array indicated by a masterside record number; a step of specifying an element in the slave sideexistence number array indicated by the pointer value, making itcorrespond to the master side record number, and placing it in a recordnumber indication array indicating the number of records of the slavetable-format data corresponding to respective records of the mastertable-format data; a step of referring to the number of records in therecord number indication array and creating a master side accumulationnumber array for storing an accumulation number of the numbers ofrecords corresponding to the master side record number; a step ofobtaining a total sum of the accumulation number of the numbers ofrecords with respect to the master side accumulation number array andcreating a new record number array capable of containing the total sumnumber of elements and for specifying new records relating to theconcatenated table-format data; a step of obtaining a first resultantarray containing a record number in the master table-format data in viewof duplication by comparing a new record number in the new record numberarray with an element in the master side accumulation number array; astep of specifying an element in the pointer array relating to the slavetable-format data and indicated by the record number in the mastertable-format data as the element in the first resultant array; a step ofspecifying an element in the slave side accumulation number arrayindicated by the element in the pointer array relating to the slavetable-format data and temporarily holding it as a slave side startaddress; and a step of obtaining a second resultant array containing arecord number in the slave table-format data in view of duplication froma record number in the record number array, an element in the masteraccumulation number array specified by the record number, and the slaveside start address, wherein the computer is operated so that the itemvalue in the value list relating to the master side information block isextracted on the basis of the record number contained in the firstresultant array, and the item value in the value list of the slave sideinformation block is extracted on the basis of the record numbercontained in the second resultant array.
 7. A concatenating/presentingprogram of concatenated table-format data, in which plural table-formatdata each expressed as an array of records containing an item and itemvalues contained therein are concatenated and the concatenatedtable-format data is presented, the program characterized by causing acomputer to execute: a step of constructing each of the table-formatdata to divide it into one or more information blocks each including avalue list in which in order of item value numbers corresponding to itemvalues belonging to a specific item, the item values are stored, and apointer array in which pointer values for indicating the item valuenumbers are stored in order of unique record numbers; a step of findingan item to be made common to the plural table-format data; a step ofspecifying information blocks relating to the item to be made common; astep of comparing value lists contained in the specified informationblocks in the plural table-format data to make both the value listsequivalent to each other; a step of, when the value lists are madeequivalent, converting a pointer array in accordance with addition of anitem value in the information block in which the item value is added andcreating a new pointer array; a step of, with respect to the pluraltable-format data and among the information blocks relating to thespecific item, deciding on table-format data in which default sort orderis reflected at presentation to be master table format data, anddeciding on table-format data other than that to be slave table-formatdata; a step of, in the information block which constitutes the slavetable-format data and in which the item value becomes equivalent,creating a slave side existence number array for storing an existencenumber indicating the number of records relating to the slavetable-format data correspondingly to the item value; a step of referringto the existence number in the slave side existence number array andcreating a slave side accumulation number array storing an accumulationnumber of the existence numbers corresponding to the item value; a stepof, in the information block which constitutes the master table-formatdata and in which the item value becomes equivalent, extracting apointer value in the pointer array indicated by a master side recordnumber; a step of specifying an element in the slave side accumulationnumber array on the basis of the pointer value, making it correspond tothe master side record number, and placing it in a record numberindication array indicating the number of records of the slavetable-format data corresponding to respective records of the mastertable-format data, the number of records being for an item value whichis not larger than the item value in the value list indicated by thepointer value or less than the item value in sort order of the masterside value list; a step of referring to the number of records in therecord number indication array and creating a master side accumulationnumber array for storing an accumulation number of the numbers ofrecords corresponding to the master side record number; a step ofobtaining a total sum of the accumulation number of the number ofrecords with respect to the master side accumulation number array andcreating a new record number array capable of containing the total sumnumber of elements and for specifying a new record relating to theconcatenated table-format data; a step of obtaining a first resultantarray containing record numbers in the master table-format data in viewof duplication by comparing a new record number in the new record numberarray with an element in the master side accumulation number array; astep of specifying an element in the pointer array relating to the slavetable-format data and indicated by the record number in the mastertable-format data as the element in the first resultant array; a step ofspecifying an element in the slave side accumulation number arrayindicated by the element in the pointer array relating to the slavetable-format data and temporarily holding it as a slave side startaddress; and a step of obtaining a second resultant array containingrecord numbers in the slave table-format data in view of duplicationfrom the record number in the record number array, the element in themaster accumulation number array specified by the record number, and theslave side start address, wherein the computer is operated so that theitem value in the value list relating to the master side informationblock is extracted on the basis of the record number contained in thefirst resultant array, and the item value in the value list of the slaveside information block is extracted on the basis of the record numbercontained in the second resultant array.
 8. The program according toclaim 7, characterized by causing the computer to execute a step ofspecifying an element in the slave side accumulation number arraycorresponding to a value larger by one than a value indicated by thepointer value, and placing, by this, it in a record number indicationarray indicating the number of records of the item value which is notlarger than the item value in the value list indicated by the pointervalue in sort order of the master side value list.
 9. The programaccording to claim 6, characterized by causing the computer to execute,in the step of creating the first resultant array, a step of specifyinga position where an element in the master accumulation number array,whose value is not larger than the new record number and is maximum, isstored, and a step of specifying an element in the new record numberarray indicated at the position and arranging it to a correspondingposition in the first resultant array.
 10. The program according toclaim 6, characterized by causing the computer to execute, in the stepof creating the second resultant array, a step of calculating adifference between a record number in the record number array and anelement in the master accumulation number array, which is not largerthan the new record number and is maximum, a step of adding the elementtemporarily held as the start address and the calculated difference, anda step of arranging a value obtained by the addition to a correspondingposition in the second resultant array.